Roe_Base Class Reference

#include <Roe_all.h>

Inheritance diagram for Roe_Base:

Public Member Functions
unsigned	IsAlive ()
int	SupplyReserves ()
virtual void	On_MumAbandon (Roe_Female *)
virtual void	On_IsDead (Roe_Base *, int, bool)
virtual void	On_EndGroup ()
virtual void	Send_IsDead ()
virtual void	On_ChangeGroup (int)
virtual void	On_UpdateGroup (int, int)
RoeDeerInfo	SupplyInfo ()
virtual void	BeginStep (void)
	BeingStep behaviour - must be implemented in descendent classes. More...
virtual void	Step (void)
	Step behaviour - must be implemented in descendent classes. More...
virtual void	EndStep (void)
	EndStep behaviour - must be implemented in descendent classes. More...
virtual int	WhatState ()
	Roe_Base (int x, int y, Landscape *L, RoeDeer_Population_Manager *RPM)
virtual	~Roe_Base ()
Public Member Functions inherited from TAnimal
unsigned	SupplyFarmOwnerRef ()
AnimalPosition	SupplyPosition ()
APoint	SupplyPoint ()
int	SupplyPolygonRef ()
int	Supply_m_Location_x ()
int	Supply_m_Location_y ()
virtual void	KillThis ()
virtual void	CopyMyself ()
void	SetX (int a_x)
void	SetY (int a_y)
	TAnimal (int x, int y, Landscape *L)
virtual void	ReinitialiseObject (int x, int y, Landscape *L)
	Used to re-use an object - must be implemented in descendent classes. More...
virtual void	Dying ()
void	CheckManagement (void)
void	CheckManagementXY (int x, int y)
virtual bool	OnFarmEvent (FarmToDo)
Public Member Functions inherited from TALMaSSObject
int	GetCurrentStateNo ()
	Returns the current state number. More...
void	SetCurrentStateNo (int a_num)
	Sets the current state number. More...
bool	GetStepDone ()
	Returns the step done indicator flag. More...
void	SetStepDone (bool a_bool)
	Sets the step done indicator flag. More...
virtual void	ReinitialiseObject ()
	Used to re-use an object - must be implemented in descendent classes. More...
	TALMaSSObject ()
	The constructor for TALMaSSObject. More...
virtual	~TALMaSSObject ()
	The destructor for TALMaSSObject. More...
void	OnArrayBoundsError ()
	Used for debugging only, tests basic object properties. More...

Public Attributes
TRoeDeerStates	CurrentRState
RoeDeer_Population_Manager *	m_OurPopulation
int	m_Age
int	m_Size
int	m_RangeCentre_x
int	m_RangeCentre_y
int	m_Reserves
double	m_HomeRange
int	m_OldRange_x
int	m_OldRange_y
int	m_SearchRange
bool	m_float
bool	m_Disperse
bool	m_HaveRange
Roe_Female *	Mum
int	m_ID
int	m_FixlistNumber
bool	m_Sex
bool	m_IsDead
unsigned	Alive

Protected Member Functions
bool	Running (int x, int y)
void	Ignore (int p_To_x, int p_To_y)
int	DistanceTo (int p_x, int p_y, int p_To_x, int p_To_y)
int	DistanceToCC (int p_x, int p_y, int p_To_x, int p_To_y)
int	DirectionTo (int p_x, int p_y, int p_To_x, int p_To_y)
int	DirectionToCC (int p_x, int p_y, int p_To_x, int p_To_y)
int	NextStep (int weight, int dir, int recurselevel)
int	AssessHabitat (int polyref)
int	AssessHabitat (int p_x, int p_y)
int	LegalHabitat (int p_x, int p_y)
int	LegalHabitatCC (int p_x, int p_y)
int	Cover (int polyref)
	Calls the cover calculation for a given polyref. More...
int	Cover (int p_x, int p_y)
	Calls the cover calculation for a given x,y location. More...
int	CalcCover (TTypesOfLandscapeElement a_ele, int a_poly)
	The cover calculation for a given element type. More...
int	CoverCC (int p_x, int p_y)
int	NutriValue (int polyref)
int	NutriValue (int p_x, int p_y)
int	NutriValueCC (int p_x, int p_y)
int	Feeding (bool p_Disperse)
void	SeekCover (int threshold)
void	SeekNutri (int p_threshold)
int	ProbRoadCross (int p_x, int p_y, int p_width)
double	CalculateRoadMortality (int p_x, int p_y, int p_width)
void	WalkTo (int pos_x, int pos_y)
void	WalkToCC (int pos_x, int pos_y)
Protected Member Functions inherited from TAnimal
void	CorrectWrapRound ()
	Corrects wrap around co-ordinate problems. More...

Protected Attributes
int	timestep
int	m_Cross_x
int	m_Cross_y
double	m_EnergyGained
int	m_RecovCount
int	m_RumiCount
int	m_FeedCount
int	m_LengthFeedPeriod
int	m_LengthRuminate
int	m_LastState
int	m_danger_x
int	m_danger_y
int	m_distrc
int	m_weightedstep
int	SimW
int	SimH
Protected Attributes inherited from TAnimal
int	m_Location_x
int	m_Location_y
Landscape *	m_OurLandscape
Protected Attributes inherited from TALMaSSObject
int	m_CurrentStateNo
	The basic state number for all objects - '-1' indicates death. More...
bool	m_StepDone
	Indicates whether the iterative step code is done for this timestep. More...

Constructor & Destructor Documentation

Roe_Base()

Roe_Base::Roe_Base	(	int	x,
		int	y,
		Landscape *	L,
		RoeDeer_Population_Manager *	RPM
	)

Roe_Base::Roe_Base - constructor for Roe base. Sets all attributes

                                                         :TAnimal(x,y,L)
{
  m_Location_x=x;
  m_Location_y=y;
  m_RangeCentre_x=x;
  m_RangeCentre_y=y;
  m_HomeRange=0;
  m_HaveRange=false;
  m_OldRange_x=x;
  m_OldRange_y=y;
  m_danger_x=0;
  m_danger_y=0;
  m_Disperse = false;
  m_float=false;
  m_OurLandscape=L;
  m_OurPopulation=RPM;
  m_FixlistNumber = -1; //not set yet
  SimW = m_OurPopulation->SimW;
  SimH = m_OurPopulation->SimH;
  m_Cross_x=x;
  m_Cross_y=y;
  CurrentRState=rds_Initialise;
  timestep=0;
  m_RumiCount=0;
  m_FeedCount=0;
  m_RecovCount=0;
  m_weightedstep=0;
  m_EnergyGained=0;
  m_LengthFeedPeriod = 3;  //in timesteps, just the first day, updated daily in UpdateEnergy
  m_LengthRuminate = 0;  //set every time roe finishes a feeding period
  Alive=0x0DEADC0DE;
}

References Alive, CurrentRState, m_Cross_x, m_Cross_y, m_danger_x, m_danger_y, m_Disperse, m_EnergyGained, m_FeedCount, m_FixlistNumber, m_float, m_HaveRange, m_HomeRange, m_LengthFeedPeriod, m_LengthRuminate, TAnimal::m_Location_x, TAnimal::m_Location_y, m_OldRange_x, m_OldRange_y, TAnimal::m_OurLandscape, m_OurPopulation, m_RangeCentre_x, m_RangeCentre_y, m_RecovCount, m_RumiCount, m_weightedstep, rds_Initialise, SimH, RoeDeer_Population_Manager::SimH, SimW, RoeDeer_Population_Manager::SimW, and timestep.

~Roe_Base()

Roe_Base::~Roe_Base ( )

virtual

{
  Alive=0;
}

References Alive.

Member Function Documentation

AssessHabitat() [1/2]

int Roe_Base::AssessHabitat ( int  p_x, int  p_y  )

protected

AssessHabitat() [2/2]

int Roe_Base::AssessHabitat ( int  polyref )

protected

BeginStep()

void Roe_Base::BeginStep ( void  )

virtual

BeingStep behaviour - must be implemented in descendent classes.

Reimplemented from TAnimal.

Reimplemented in Roe_Male, Roe_Female, Roe_Fawn, and Roe_Adult_Base.

{
 if (m_CurrentStateNo==-1) return;
}

References TALMaSSObject::m_CurrentStateNo.

CalcCover()

int Roe_Base::CalcCover ( TTypesOfLandscapeElement  a_ele, int  a_poly  )

protected

The cover calculation for a given element type.

Each type of habitat is given a relative cover value for an adult roe from 0-4. Non-habitat is given a value of -1. Openland with very low veg = 0. Related to VegHeight and type of veg. In open land all that matters is VegHeight

Todo:

Decide on classification for new tole types for roe deer 3

{
  int cov;
  int height;
  char errornum[20];
  switch(a_ele)
  {
     case tole_BareRock:
     case tole_UrbanNoVeg:
     case tole_UrbanPark:
     case tole_SandDune:
     case tole_Churchyard:  //204
     case tole_BuiltUpWithParkland:
     case tole_Carpark:
     case tole_Building:
     case tole_Garden:
     case tole_Saltwater:
     case tole_Pond:
     case tole_Freshwater:
     case tole_River:
     case tole_Coast:
     case tole_ActivePit:
     case tole_Railway:
     case tole_HeritageSite:
     case tole_Stream:
       cov=-2;
       break;
 
     case tole_RoadsideVerge:
     case tole_StoneWall:
     case tole_Fence:
     case tole_RoadsideSlope:
       cov=0;
       break;
 
     case tole_NaturalGrassDry: // 110
     case tole_NaturalGrassWet: // 110
     case tole_MownGrass: // 58
     case tole_OrchardBand: // 57
     case tole_Saltmarsh: // 95
     case tole_Heath:
     case tole_AmenityGrass:
     case tole_PermPasture:
     case tole_PermPastureLowYield:
     case tole_PermPastureTussocky:
     case tole_Marsh:
     case tole_Field:
     case tole_PermanentSetaside:
         cov = 1 + (int)floor(m_OurLandscape->SupplyVegHeight(a_poly)*0.02);
       if ( cov > 4 )
         cov = 4;
       break;
     case tole_DeciduousForest:
     case tole_ConiferousForest:
     case tole_MixedForest:
     case tole_Copse:
     case tole_IndividualTree:
       height = m_OurLandscape->SupplyTreeHeight(a_poly);
       if(height<=10) cov = 3;
       else cov = 2;
       break;
 
     case tole_YoungForest:  //new class 55
     case tole_Scrub:
     case tole_PitDisused:
     case tole_RiversideTrees:
     case tole_HedgeBank: // added by ljk 13/7/2012
     case tole_Hedges:
 
       cov=3;
       break;
 
     case tole_RiversidePlants:
     case tole_FieldBoundary:
         if (m_OurLandscape->SupplyVegHeight(a_poly)<100) cov = 2;
       else cov=3;
       break;
 
     case tole_LargeRoad:
     case tole_SmallRoad:
     case tole_Track:
       cov=-1;           //need to distingues roads from other non-habitats
       break;
 
     case tole_Foobar:
       sprintf(errornum, "%d", a_ele);
       m_OurLandscape->Warn("Roe_Base::Cover(): Unknown element type!",
                       errornum);
       exit( 1 );
       break;
     case tole_PlantNursery:
     case tole_Vildtager:
     case tole_WindTurbine:
     case tole_WoodyEnergyCrop:
     case tole_WoodlandMargin:
     case tole_Pylon:
     default:
      //throw an error
      sprintf(errornum, "%d", a_ele);
      m_OurLandscape->Warn("Roe_Base::Cover(): Unknown element type!",
                       errornum);
      exit( 1 );
      break;
  }
  return cov;
}

References TAnimal::m_OurLandscape, Landscape::SupplyTreeHeight(), Landscape::SupplyVegHeight(), tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Fence, tole_Field, tole_FieldBoundary, tole_Foobar, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_OrchardBand, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, and Landscape::Warn().

Referenced by Cover().

CalculateRoadMortality()

double Roe_Base::CalculateRoadMortality ( int  p_x, int  p_y, int  p_width  )

protected

Roe_Base::CalculateRoadMortality - calculates the mortality probability of crossing a road, depending on traffic load, probability of car passing as roe deer is passing, given this - probability of roe deer getting hit. Calls function SupplyTrafficLoad().

{
   //get trafficload
   double traffic=(double) m_OurLandscape->SupplyTrafficLoad(p_x,p_y); //cars/hr
   //prob of a car passing while roe is crossing
   double cars =((double)traffic/1200);  //cars/3 sec
   int rand = random(100);
   if ((double)rand<((double)cars*100))  //a car is passing, so calculate roes prob of getting hit
   {
     //Every cars that passes while roe is crossing is only lethal on half the
     //roadwidth. Lethalwidth is thus=0.5*p_width.
     //Prob of getting killed is 1-(1-(lethalwidth/p_width))^lethalcars.
     //Lethalwidth/p_width=0.5, so inner brackets=0.5
     //The prob. of getting killed is thus 1-(0.5^cars)
     return (double) (100*(1-pow(double(0.5),cars)));
   }
   else return 0;  //no car passing
}

References TAnimal::m_OurLandscape, random(), and Landscape::SupplyTrafficLoad().

Referenced by NextStep(), Running(), Roe_Fawn::RunTo(), and WalkTo().

Cover() [1/2]

int Roe_Base::Cover ( int  p_x, int  p_y  )

protected

Calls the cover calculation for a given x,y location.

{
    return CalcCover(m_OurLandscape->SupplyElementType(p_x, p_y), m_OurLandscape->SupplyPolyRef(p_x, p_y));
}

References CalcCover(), TAnimal::m_OurLandscape, Landscape::SupplyElementType(), and Landscape::SupplyPolyRef().

Cover() [2/2]

int Roe_Base::Cover ( int  a_polyref )

protected

Calls the cover calculation for a given polyref.

Roe_Base::Cover - Input coordinates. Each type of habitat is given a relative cover value for an adult roe deer from 0-4. Non-habitat is given a value of -1. Open land with very low veg = 0. Related to VegHeight and type of vegetation. In open land all that matters is VegHeight. Returns cover value. Calls functions SupplyElementType(), SupplyVegHeight() and SupplyTreeHeight().

{
    return CalcCover(m_OurLandscape->SupplyElementType(a_polyref), a_polyref);
}

References CalcCover(), TAnimal::m_OurLandscape, and Landscape::SupplyElementType().

Referenced by Roe_Fawn::FARuminate(), Roe_Female::FRuminate(), Roe_Male::MRuminate(), Roe_Female::On_ApproachOfDanger(), Roe_Male::On_ApproachOfDanger(), Running(), and SeekCover().

CoverCC()

int Roe_Base::CoverCC ( int  p_x, int  p_y  )

inlineprotected

corrects coordinates (for cover) for wrap around landscape

   {
     m_OurLandscape->CorrectCoords( p_x, p_y );
     return Cover( p_x, p_y );
   }

Referenced by SeekCover().

DirectionTo()

int Roe_Base::DirectionTo ( int  p_x, int  p_y, int  p_To_x, int  p_To_y  )

protected

Roe_Base::DirectionTo - calculates direction to a specific location

{
  double a = double(p_x-p_To_x);
  double b = double(p_y-p_To_y);
  int thisway=0;
 
  if ((b>SimH/2)||(b*-1>SimH/2))
  {
    b=b*-1;
  }
  if((a>SimW/2)||(a*-1>SimW/2))
  {
    a=a*-1;
  }
  if (a > 0)
  {
    if (b>0) thisway=7;
    else if (b<0)
    {
      thisway=5;
    }
    else thisway=6; //b=0
  }
  else if (a < 0)
  {
    if (b>0) thisway=1;
    else if (b<0) thisway=3;
    else thisway=2;
  }
  else if (a==0)
  {
    if (b>0) thisway=0;
    else thisway=4;
  }
  return thisway;
}

References SimH, and SimW.

Referenced by Roe_Fawn::FAFeed(), Roe_Female::FDisperse(), Feeding(), Roe_Female::FEvade(), Roe_Male::MDisperse(), Roe_Male::MEvade(), Running(), Roe_Fawn::RunTo(), and WalkTo().

DirectionToCC()

int Roe_Base::DirectionToCC ( int  p_x, int  p_y, int  p_To_x, int  p_To_y  )

inlineprotected

   {
     m_OurLandscape->CorrectCoords( p_x, p_y );
     return DirectionTo( p_x, p_y, p_To_x, p_To_y );
   }

Referenced by WalkTo().

DistanceTo()

int Roe_Base::DistanceTo ( int  p_x, int  p_y, int  p_To_x, int  p_To_y  )

protected

Roe_Base::DistanceTo - calculates distance from 2 coordinates to other 2 coordinates.

{
   int x = (p_x - p_To_x);
   int y = (p_y - p_To_y);
   if(x<0) x = x * -1;
   if (y<0) y = y * -1;
   if (x > (SimW/2))  x = SimW - x;
   if (y > (SimH/2))  y = SimH - y;
   if ((x!=0)||(y!=0))
   {
     return (int)(sqrt(double ((x*x) + (y*y))));
   }
   else return 0; // in the case where roe is standing on p_To_x,p_To_y
}

References SimH, and SimW.

Referenced by Roe_Male::BeginStep(), Roe_Fawn::FAFeed(), Roe_Fawn::FASuckle(), Feeding(), Roe_Female::FEstablishRange(), Roe_Female::FOnNewDay(), Roe_Male::MOnNewDay(), Roe_Fawn::On_ApproachOfDanger(), Roe_Female::On_ApproachOfDanger(), Roe_Male::On_ApproachOfDanger(), Roe_Male::On_InHeat(), Roe_Male::On_Rank(), Roe_Fawn::RunTo(), Roe_Fawn::SelectBedSite(), and WalkTo().

DistanceToCC()

int Roe_Base::DistanceToCC ( int  p_x, int  p_y, int  p_To_x, int  p_To_y  )

inlineprotected

   {
     m_OurLandscape->CorrectCoords( p_x, p_y );
     m_OurLandscape->CorrectCoords( p_To_x, p_To_y );
     return DistanceTo( p_x, p_y, p_To_x, p_To_y );
  }

Referenced by Roe_Female::FEstablishRange(), and WalkTo().

EndStep()

void Roe_Base::EndStep ( void  )

virtual

EndStep behaviour - must be implemented in descendent classes.

Reimplemented from TAnimal.

Reimplemented in Roe_Male, Roe_Female, Roe_Fawn, and Roe_Adult_Base.

{
  if (m_StepDone || (m_CurrentStateNo==-1)) return;
}

References TALMaSSObject::m_CurrentStateNo, and TALMaSSObject::m_StepDone.

Feeding()

int Roe_Base::Feeding ( bool  p_Disperse )

protected

Roe_Base::Feeding - When habitat has been deemed suitable for feeding, next step is to evaluate whether steps should be weighted towards range centre or not. To avoid that animals gets trapped when using very directed walk, their progress during the last hour (6 timesteps) is monitored. Calls DistanceTo(), NextStep().

{
  //Habitat is suitable for feeding. Now evaluate whether steps should be
  //weighted towards range centre or not
 
    int weight;
    int dir;
    int distrc;
 
    //first get distance and direction back to range centre
    distrc=DistanceTo(m_Location_x, m_Location_y, m_RangeCentre_x, m_RangeCentre_y);
    dir=DirectionTo(m_Location_x, m_Location_y, m_RangeCentre_x, m_RangeCentre_y);
 
    //to avoid that animals gets trapped when using very directed walk, keep track
    //of their progress during the last hour (6 timesteps)
    if ((m_weightedstep>5)&&(m_distrc-distrc<50))
    { //must be stuck so take the next steps without weight
       weight=0;
    }
    else
    {
      if ((p_Disperse==true)||(distrc<=m_SearchRange))  //don't worry about rangecentre
      {
        weight=0;
        m_weightedstep=0;
      }
      else
      {
        if(distrc<=m_SearchRange+100) weight=1;
         else if ((distrc>m_SearchRange+100)&&(distrc<=m_SearchRange+200)) weight=2;
          else if (distrc>m_SearchRange+200)   weight=3;
        m_weightedstep++;
        m_distrc = distrc;
      }
    }
 
    //take the steps
    if (NextStep(weight,dir,0)==-1) // roe has taken a step and died doing it
    {
       m_IsDead=true;
    }
    return 0;
}

References DirectionTo(), DistanceTo(), m_distrc, m_IsDead, TAnimal::m_Location_x, TAnimal::m_Location_y, m_RangeCentre_x, m_RangeCentre_y, m_SearchRange, m_weightedstep, and NextStep().

Referenced by Roe_Female::FFeed(), and Roe_Male::MFeed().

Ignore()

void Roe_Base::Ignore ( int  p_To_x, int  p_To_y  )

protected

IsAlive()

unsigned Roe_Base::IsAlive ( )

inline

{return Alive;}

Referenced by Roe_Male::AddSatellite(), RoeDeer_Population_Manager::AddToFightlist(), RoeDeer_Population_Manager::AddToGroup(), Roe_Fawn::BeginStep(), Roe_Female::BeginStep(), Roe_Male::BeginStep(), RoeDeer_Population_Manager::CreateNewGroup(), RoeDeer_Population_Manager::DoFirst(), Roe_Fawn::EndStep(), Roe_Female::EndStep(), Roe_Male::EndStep(), Roe_Fawn::FADie(), Roe_Fawn::FAFeed(), Roe_Fawn::FAHide(), Roe_Fawn::FAInit(), Roe_Fawn::FAOnNewDay(), Roe_Fawn::FARecover(), Roe_Fawn::FARuminate(), Roe_Fawn::FARunToMother(), Roe_Fawn::FASuckle(), Roe_Fawn::FAUpdateEnergy(), Roe_Female::FCareForYoung(), Roe_Female::FDie(), Roe_Female::FDisperse(), Roe_Female::FEstablishRange(), Roe_Female::FEvade(), Roe_Female::FFeed(), Roe_Female::FFormGroup(), Roe_Female::FGiveBirth(), Roe_Female::FIgnore(), Roe_Female::FInHeat(), Roe_Female::FMate(), Roe_Female::FOnMature(), Roe_Female::FOnNewDay(), Roe_Female::FRecover(), Roe_Female::FRuminate(), Roe_Female::FRun(), Roe_Female::FUpdateEnergy(), Roe_Female::FUpdateGestation(), Roe_Male::MAttendFemale(), Roe_Male::MDie(), Roe_Male::MDisperse(), Roe_Male::MEstablishRange(), Roe_Male::MEstablishTerritory(), Roe_Male::MEvade(), Roe_Male::MFeed(), Roe_Male::MFight(), Roe_Male::MIgnore(), Roe_Male::MMate(), Roe_Male::MOnMature(), Roe_Male::MOnNewDay(), Roe_Male::MRecover(), Roe_Male::MRuminate(), Roe_Male::MRun(), Roe_Male::MUpdateEnergy(), NextStep(), Roe_Male::On_Expelled(), Roe_Male::On_InHeat(), Roe_Fawn::On_IsDead(), Roe_Female::On_IsDead(), Roe_Male::On_IsDead(), Roe_Male::On_NewHost(), RoeDeer_Population_Manager::RemoveFromFightlist(), RoeDeer_Population_Manager::RemoveFromGroup(), Roe_Male::RemoveSatellite(), Roe_Female::Roe_Female(), Roe_Male::Roe_Male(), Roe_Female::Send_EndGroup(), Roe_Fawn::Step(), Roe_Female::Step(), and Roe_Male::Step().

LegalHabitat()

int Roe_Base::LegalHabitat ( int  p_x, int  p_y  )

protected

Roe_Base::LegalHabitat - returns a value indicating whether element type can be crossed or not. -1: lethal, cannot be crossed, 0: roads, needs evaluation, 1: can be crossed

Todo:

Decide on classification for new tole types for roe deer 2

{
  //returns a value indicating whether element type can be crossed or not.
  //-1: lethal, cannot be crossed, 0: roads, needs evaluation, 1: can be crossed
  TTypesOfLandscapeElement Elem=m_OurLandscape->SupplyElementType(p_x,p_y);
  int value;
  switch(Elem)
  {
     case tole_Building:
     case tole_Garden:
     case tole_StoneWall:
     case tole_Fence:
     case tole_Saltwater:
     case tole_Pond:
     case tole_Freshwater:
     case tole_River:
     case tole_Stream:
     case tole_ActivePit:
     case tole_UrbanNoVeg:
     case tole_Churchyard:  //204
     case tole_BuiltUpWithParkland:
     case tole_Carpark:
     case tole_RoadsideSlope:
     case tole_BareRock:
         value = -1;
       break;
 
     case tole_Field:
     case tole_RoadsideVerge:
     case tole_PermPasture:
     case tole_PermPastureLowYield:
     case tole_PermPastureTussocky:
     case tole_DeciduousForest:
     case tole_ConiferousForest:
     case tole_MixedForest:
     case tole_YoungForest:   //new class 55
     case tole_Copse:
     case tole_Scrub:
     case tole_PitDisused:
     case tole_RiversideTrees:
     case tole_RiversidePlants:
     case tole_NaturalGrassDry:
     case tole_NaturalGrassWet:
     case tole_Coast:
     case tole_PermanentSetaside:
     case tole_Railway:
     case tole_Track:
     case tole_Hedges:
     case tole_HedgeBank: 
     case tole_FieldBoundary:
     case tole_Marsh:
     case tole_MownGrass: // 58
     case tole_OrchardBand: // 57
     case tole_Orchard: //56
     case tole_Saltmarsh: // 95
     case tole_Heath:
     case tole_AmenityGrass:
     case tole_UrbanPark:
     case tole_SandDune:
     case tole_HeritageSite:
         value = 1;
       break;
 
     case tole_LargeRoad:
     case tole_SmallRoad:
       value=0;
       break;
 
     case tole_Foobar:
       m_OurLandscape->Warn("Roe_Base::LegalHabitat(): Unknown element type!", g_landscape_p->PolytypeToString(Elem));
       exit( 1 );
       break;
     case tole_IndividualTree:
     case tole_PlantNursery:
     case tole_Vildtager:
     case tole_WindTurbine:
     case tole_WoodyEnergyCrop:
     case tole_WoodlandMargin:
     case tole_Pylon:
     default:
      //throw an error
     m_OurLandscape->Warn("Roe_Base::LegalHabitat(): Unknown element type!", g_landscape_p->PolytypeToString(Elem));
     exit( 1 );
    break;
  }
  return value;
}

References g_landscape_p, TAnimal::m_OurLandscape, Landscape::PolytypeToString(), Landscape::SupplyElementType(), tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Fence, tole_Field, tole_FieldBoundary, tole_Foobar, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_OrchardBand, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, and Landscape::Warn().

Referenced by Roe_Female::FEstablishRange(), and NextStep().

LegalHabitatCC()

int Roe_Base::LegalHabitatCC ( int  p_x, int  p_y  )

inlineprotected

LegalHabitatCC -calls LegalHabitat witth coordinates corrected for wrap-around

   {
     m_OurLandscape->CorrectCoords( p_x, p_y );
     return LegalHabitat( p_x, p_y );
   }

Referenced by Roe_Female::FEstablishRange(), NextStep(), and WalkTo().

NextStep()

int Roe_Base::NextStep ( int  weight, int  dir, int  recurselevel  )

protected

Roe_Base::NextStep - This function makes the animal object perform a semirandom walk choosing best feeding habitat based on cover and nutri.value one step at a time. Equals 10 minutes of activity. Calls functions LegalHabitatCC(), SupplyElementType(), SupplyRoadWidth(), ProbRoadCross(), CalculateRoadMortality(), LegalHabitat(), SupplyPolyRef(),CorrectWidth(), CorrectHeight(), SuplyPolyRefCC().

{
  // **FN** Tunet 15/6-2001.
 
  #ifdef JUJ__Debug3
  if(IsAlive()!=0x0DEADC0DE)
  {
    m_OurLandscape ->Warn("Roe_Base:NextStep():Deadcode warning","");
    exit( 1 );
  }
  #endif
  //semirandom walk choosing best feeding habitat based on cover and nutri.value
  //One step at a time. Equals 10 minutes of activity
  if(recurselevel>2)
  {
    m_OurLandscape ->Warn("Roe_Base:NextStep():Variable out of range, recurselevel","");
    exit( 1 );
  }
 
  int t[8];
  t[0] = dir;
  t[1] = (dir+ 9) & 7;
  t[2] = (dir+ 7) & 7;
  t[3] = (dir+ 10) & 7;
  t[4] = (dir + 6) & 7;
  t[5] = (dir+ 11) & 7;
  t[6] = (dir + 5) & 7;
  t[7] = (dir + 12) & 7;
  int q[8]= {0};
  int x = m_Location_x;
  int y = m_Location_y;
  bool found=false;
  bool correct=false;
  int step=0;
  int check=-2;
  int index[8]= {0};
  int best=-1;
  int score = -1;
  int thissquare;
  int d[5]={8,7,5,3,1};
 
  //check whether you step out of area. If so use % Sim, else not
  if((x <= 200)||(x >= SimW-200)||(y <= 200)||(y >= SimH-200)) //next step could take you out of area
  {
    x += SimW;
    y += SimH;
    correct=true;
  }
  if(correct==true)
  {
    //take 50 steps
    for(int i=0;i<50;i++)
    {
      q[0] = LegalHabitatCC( x+Vector_x[t[0]], y+Vector_y[t[0]] );
      q[1] = LegalHabitatCC( x+Vector_x[t[1]], y+Vector_y[t[1]] );
      q[2] = LegalHabitatCC( x+Vector_x[t[2]], y+Vector_y[t[2]] );
      q[3] = LegalHabitatCC( x+Vector_x[t[3]], y+Vector_y[t[3]] );
      q[4] = LegalHabitatCC( x+Vector_x[t[4]], y+Vector_y[t[4]] );
      q[5] = LegalHabitatCC( x+Vector_x[t[5]], y+Vector_y[t[5]] );
      q[6] = LegalHabitatCC( x+Vector_x[t[6]], y+Vector_y[t[6]] );
      q[7] = LegalHabitatCC( x+Vector_x[t[7]], y+Vector_y[t[7]] );
       //q[i]=-1,non-habitat, q[i]=0,road, q[i]=1 suitable
 
      for (int j=0; j<d[weight]; j++)     //score as many squares as needed
      {
        if (q[j]>=0)  //scores all suitable and finds the best square
        {
          score++;
          index[score]=j;
        }
      }
      if (score==-1) //no suitable options,
      {
         if((recurselevel==2)||(NextStep(0,dir,++recurselevel)==-1))
         {
           return -1;
         }
         else
         {
           return 0;
         }
      }
      else //pick random
      {
        //pick random from those available
        thissquare = random(score+1);
        best=q[index[thissquare]];
      }
      if (best==0)  //roads or rivers/streams
      {
        //rivers are crossed 50:50. Roads depend on width and traffic load
         int cross=random(100);
         int hab=-2;
         int prob=50;
         int width=0;
         double mort=0;
     int xi = x+Vector_x[t[index[thissquare]]];
     int yi = y+Vector_y[t[index[thissquare]]];
     m_OurLandscape->CorrectCoords( xi, yi );
 
         if(m_OurLandscape->SupplyElementType( xi, yi )!=tole_River)  //road
         { //get width of road
            width=m_OurLandscape->SupplyRoadWidth( xi, yi );
            prob=ProbRoadCross( xi, yi, width );
            //take mortality test
            mort=CalculateRoadMortality( xi, yi, width );
         }
         if (cross<prob) //yes, roe will cross
         {
           //does it survive?
            int die=random(100);
            if (die<mort)
            {
              return -1;  //roe is dead
            }
           //Locate other side of the road. First in preferred direction and if
           //not found continue clockwise in all other directions
           int preferred=index[thissquare]; //preferred direction
           for (int k=0;k<8;k++) //in each direction
           {
             #ifdef JUJ__Debug2
               if(preferred>14)
               {
                 m_OurLandscape ->Warn("Roe_Base:NextStep():Variable out of range, preferred","");
                 exit( 1 );
               }
             #endif
             for(int j=1;j<20;j++)
             {
               hab=LegalHabitatCC( x+(Vector_x[t[preferred&7]]*j),
                   y+(Vector_y[t[preferred&7]]*j) );
               if(hab>0) //other side found
               {
                 //check 3 steps further on other side of road or stream.
                 //If road or urban (check = -1) you can't cross
                 check = LegalHabitatCC( x+(Vector_x[t[preferred&7]]*(j+3)),
                     y+(Vector_y[t[preferred&7]]*(j+3)) );
                 if(check>0) //OK
                 {
                   found=true;
                   step=j;   //need to walk this many steps to get across
                   index[thissquare] = preferred & 7;  //this direction
                 }
                 break;
               }
             }
             if(!found) preferred++;
 
             else break;
           }
         }
      if(!found) //would or could not cross
    { //score again, but don't include road or river
      score=-1;
      for (int j=0;j<d[weight];j++)
        {
          if (q[j]>0)
        {
          score++;
          index[score]=j;
        }
        }
      //pick random from those available
      thissquare = random(score+1);
      best=q[index[thissquare]];
    }
 
      if (score==-1) //no suitable options,
    {
      if((recurselevel==2) ||(NextStep(0,dir,++recurselevel)==-1))  //recursive function
        {
          return -1;
        }
      else
        {
          return 0;
        }
    }
    }
 
    // best way is now found, so check if you are crossing
    // into a new polygon?
    if (m_OurLandscape->
    SupplyPolyRefCC( x+Vector_x[t[index[thissquare]]],
             y+Vector_y[t[index[thissquare]]])
    != m_OurLandscape->SupplyPolyRefCC( x, y )) {
      m_Cross_x=m_OurLandscape->CorrectWidth( x );
      m_Cross_y=m_OurLandscape->CorrectHeight( y );
    }
    //change coordinates
    if(found)  //roe is crossing a road or river
      {
         x+=(Vector_x[t[index[thissquare]]]*step);
         y+=(Vector_y[t[index[thissquare]]]*step);
         step=0;
      }
      else
      {
         x+=Vector_x[t[index[thissquare]]];
         y+=Vector_y[t[index[thissquare]]];
      }
      score=-1;
      found=false;
    }
  }
 
  //PART 2 don't need area correction
 
  else
  {
    //take 50 steps
    for(int i=0;i<50;i++)
    {
      q[0] = LegalHabitat(x+Vector_x[t[0]],y+Vector_y[t[0]]);
      q[1] = LegalHabitat (x+Vector_x[t[1]],y+Vector_y[t[1]]);
      q[2] = LegalHabitat (x+Vector_x[t[2]],y+Vector_y[t[2]]);
      q[3] = LegalHabitat (x+Vector_x[t[3]],y+Vector_y[t[3]]);
      q[4] = LegalHabitat (x+Vector_x[t[4]],y+Vector_y[t[4]]);
      q[5] = LegalHabitat (x+Vector_x[t[5]],y+Vector_y[t[5]]);
      q[6] = LegalHabitat (x+Vector_x[t[6]],y+Vector_y[t[6]]);
      q[7] = LegalHabitat (x+Vector_x[t[7]],y+Vector_y[t[7]]);
       //q[i]=-1,non-habitat, q[i]=0,road, q[i]=1 suitable
 
        for (int j=0; j<d[weight]; j++)     //score as many squares as needed
        {
          if (q[j]>=0)  //score only road or better
          {
            score++;
            index[score]=j;
          }
        }
        if (score==-1) //no suitable options,
        {
           if((recurselevel==2)||(NextStep(0,dir,++recurselevel)==-1))
           {
             return -1;
           }
           else
           {
             return 0;
           }
        }
        else
        {
          //pick random from those available
          thissquare = random(score+1);
          best=q[index[thissquare]];
        }
        if (best==0)  //roads or rivers/streams
        {
        //rivers are crossed 50:50. Roads depend on width and traffic load
         int cross=random(100);
         int hab=-2;
         int prob=50;
         int width=0;
         double mort=0;
     int xi = x+Vector_x[t[index[thissquare]]];
     int yi = y+Vector_y[t[index[thissquare]]];
         if(m_OurLandscape->SupplyElementType( xi, yi )!=tole_River)  //road
         { //get width of road
            width=m_OurLandscape->
          SupplyRoadWidth( xi, yi );
            prob=ProbRoadCross( xi, yi, width );
            //take mortality test
            mort=CalculateRoadMortality( xi, yi, width );
         }
         if (cross<prob) //yes, roe will cross
         {
           //does it survive?
            int die=random(100);
            if (die<mort)
            {
              return -1;  //roe is dead
            }
           //Locate other side of the road. First in preferred direction and if
           //not found continue clockwise in all other directions
           int preferred=index[thissquare]; //preferred direction
           for (int k=0;k<8;k++) //in each direction
           {
             #ifdef JUJ__Debug2
               if(preferred>14)
               {
                 m_OurLandscape ->Warn("Roe_Base:NextStep():Variable out of range, preferred","");
                 exit( 1 );
               }
             #endif
             for(int j=1;j<20;j++)
             {
               hab=LegalHabitat((x+(Vector_x[t[preferred&7]]*j)),
                (y+(Vector_y[t[preferred&7]]*j)));
               if(hab>0) //other side found
               {
                 //check 3 steps further on other side of road or stream.
                 //If road or urban you can't cross
                 check = LegalHabitat( x+(Vector_x[t[preferred&7]]*(j+3)),
                       y+(Vector_y[t[preferred&7]]*(j+3)) );
 
                 if(check>0) //OK
                 {
                   found=true;
                   step=j;   //need to walk this many steps to get across
                   index[thissquare] = preferred & 7;  //this direction
                 }
                 break;
               }
             }
             if(!found) preferred++;
             else break;
           }
         }
         if(!found) //would or could not cross
         { //score again, but don't include road or river
           score=-1;
           for (int j=0;j<d[weight];j++)
           {
             if (q[j]>0)
             {
               score++;
               index[score]=j;
             }
           }
           //pick random from those available
           thissquare = random(score+1);
           best=q[index[thissquare]];
         }
 
         if (score==-1) //no suitable options,
         {
           if((recurselevel==2)||(NextStep(0,dir,++recurselevel)==-1))  //recursive function
           {
             return -1;
           }
           else
           {
             return 0;
           }
         }
       }
         
        // best way is now found, so check if you are crossing
    // into a new polygon?
        if (m_OurLandscape->
        SupplyPolyRef(x+Vector_x[t[index[thissquare]]],
              y+Vector_y[t[index[thissquare]]])
        != m_OurLandscape->SupplyPolyRef(x,y))
        {
          m_Cross_x=x;
          m_Cross_y=y;
        }
        //change coordinates
        if(found==true)  //roe is crossing a road
        {
          x+=(Vector_x[t[index[thissquare]]]*step);
          y+=(Vector_y[t[index[thissquare]]]*step);
        }
        else
        {
          x+=Vector_x[t[index[thissquare]]];
          y+=Vector_y[t[index[thissquare]]];
        }
        score=-1;
        found=false;
    } //end of 50 steps
  }
 
  //update roes location
  if(correct==true)
  {
    m_Location_x = m_OurLandscape->CorrectWidth( x );
    m_Location_y = m_OurLandscape->CorrectHeight( y );
  }
  else
  {
    m_Location_x = x;
    m_Location_y = y;
  }
  return 0;
}

References CalculateRoadMortality(), Landscape::CorrectCoords(), Landscape::CorrectHeight(), Landscape::CorrectWidth(), IsAlive(), LegalHabitat(), LegalHabitatCC(), m_Cross_x, m_Cross_y, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, ProbRoadCross(), random(), SimH, SimW, Landscape::SupplyElementType(), Landscape::SupplyPolyRef(), Landscape::SupplyPolyRefCC(), Landscape::SupplyRoadWidth(), tole_River, Vector_x, Vector_y, and Landscape::Warn().

Referenced by Roe_Fawn::FAFeed(), Roe_Female::FDisperse(), Feeding(), Roe_Female::FEvade(), Roe_Male::MDisperse(), and Roe_Male::MEvade().

NutriValue() [1/2]

int Roe_Base::NutriValue ( int  p_x, int  p_y  )

protected

Roe_Base::NutriValue - returns the amount of energy gained per 10 minutes in a particular polygon. Two switch statements; 1 for element type and 1 for crop type if field. Digestable energy content (DEC) is scaled to a monthly estimate of intake rate. Returns DEC value. calls functions SupplyElementType(), SupplyVegType(), SupplyVegBiomass().

Todo:

Decide on classification for new tole types for roe deer 1

{
    //Nutrivalue returns the amount of energy gained per 10 minutes in this polygon.
    //Two switch statements; 1 for element typse and 1 for crop type if field.
    //Digestable energy content (DEC) is scaled to a monthly estimate of intake rate.
 
    int DEC = 0; //digestable energy content
    double nutri = 0;   //energy gain per minute
    int day = m_OurLandscape->SupplyDayInYear();
    TTypesOfLandscapeElement Elem = m_OurLandscape->SupplyElementType(p_x, p_y);
 
    int month = m_OurLandscape->SupplyMonth();
    if (Elem != tole_Field)
    {
        switch (Elem)//all but field returns value in this switch
        {
        case tole_Building:
        case tole_Garden:
        case tole_StoneWall:
        case tole_Fence:
        case tole_Pond:
        case tole_Freshwater:
        case tole_Saltwater:
        case tole_River:
        case tole_Coast:
        case tole_ActivePit:
        case tole_Railway:
        case tole_LargeRoad:
        case tole_SmallRoad:
        case tole_Track:
        case tole_Carpark:
        case tole_UrbanNoVeg:
        case tole_Stream:
        case tole_AmenityGrass:
        case tole_Saltmarsh:
        case tole_Churchyard:
        case tole_BareRock:
        case tole_SandDune:
        case tole_IndividualTree:
        case tole_PlantNursery:
        case tole_Vildtager:
        case tole_WindTurbine:
        case tole_WoodyEnergyCrop:
        case tole_WoodlandMargin:
        case tole_Pylon:
 
            DEC = 0;     //non habitats return 0
            break;
 
        case tole_Marsh:
        case tole_ConiferousForest:
            DEC = 950;
            break;
 
        case tole_Heath:
        case tole_RoadsideVerge:
        case tole_RoadsideSlope:
        case tole_PermPasture:
        case tole_PermPastureLowYield:
        case tole_PermPastureTussocky:
        case tole_PermanentSetaside:
        case tole_PitDisused:
        case tole_NaturalGrassDry:
        case tole_NaturalGrassWet:
        case tole_RiversidePlants:
        case tole_FieldBoundary:
        case tole_HeritageSite:
            DEC = 1200;
            break;
 
        case tole_Orchard:
        case tole_DeciduousForest:
        case tole_MixedForest:
        case tole_Scrub:
        case tole_Hedges:
        case tole_HedgeBank: // added by ljk on 13/7/2012
        case tole_RiversideTrees:
        case tole_Copse:
            if ((day > 100) && (day < 270)) DEC = 1400;
            else DEC = 950;
            break;
 
        case tole_YoungForest:   //new class 55
            if ((day > 100) && (day < 270)) DEC = 1500;
            else DEC = 950;
            break;
 
        case tole_Foobar:
            m_OurLandscape->Warn("Roe_Base::NutriValue(x,y): Unknown element type!", "tole_Foobar");
            exit(1);
            break;
        default:
            //throw an error
            m_OurLandscape->Warn("Roe_Base::NutriValue(x,y): Unknown element type!", g_landscape_p->PolytypeToString(Elem));
            exit(1);
            break;
        }
    }
    else //is field
    {
        //get crop type
        TTypesOfVegetation VegType = m_OurLandscape->SupplyVegType(p_x, p_y);
        double Biomass = ((double)m_OurLandscape->SupplyVegBiomass(p_x, p_y));
        if (Biomass > 160) //ljk 31/7-2012, 160 - is this an arbitrary value?? Where does it come from? Is it just calibrated this way?
        {
            switch (VegType)  //veg. or croptype as applicable
            {
            case tov_SpringBarley:
            case tov_SpringBarleySpr:
            case tov_Oats:
            case tov_OOats:
            case tov_SpringBarleySilage:
            case tov_OSpringBarley:
            case tov_WinterBarley:
            case tov_WinterWheat:
            case tov_WinterRye:
            case tov_OWinterBarley:
            case tov_OWinterRye:
            case tov_Triticale:     
            case tov_OTriticale:
            case tov_OWinterWheat:
 
            case tov_Maize:
            case tov_OMaizeSilage:
            case tov_MaizeSilage:
            case tov_MaizeStrigling:
                DEC = 1200;
                break;
 
                //seed- and permanent grass, same as natural grassy habitats
            case tov_Setaside:
            case tov_PermanentGrassGrazed:
            case tov_OPermanentGrassGrazed:
            case tov_SeedGrass1:
            case tov_SeedGrass2:
            case tov_PermanentSetaside:
            case tov_Heath:
                DEC = 1100;
                break;
 
                //undersown crops and clover grass
            case tov_OWinterWheatUndersown:
            case tov_SpringBarleyCloverGrass:
            case tov_SpringBarleyGrass:
            case tov_OBarleyPeaCloverGrass:
            case tov_OSBarleySilage:
            case tov_CloverGrassGrazed1:
            case tov_CloverGrassGrazed2:
            case tov_OCloverGrassGrazed1:
            case tov_OCloverGrassGrazed2:
            case tov_OCloverGrassSilage1:
                DEC = 1300;
                break;
 
                //high quality crops
            case tov_FieldPeas:
            case tov_BroadBeans:
            case tov_FodderBeet:
            case tov_SugarBeet:
            case tov_OFodderBeet:
            case tov_OFieldPeas:
            case tov_OFieldPeasSilage:
                DEC = 1500;
                break;
 
                //no-good crops
            case tov_SpringRape:
            case tov_WinterRape:
            case tov_OWinterRape:
            case tov_OGrazingPigs:
            case tov_OSpringBarleyPigs:
            case tov_OCarrots:
            case tov_Potatoes:
            case tov_PotatoesIndustry:
            case tov_OPotatoes:
                DEC = 100;
                break;
 
                //others
            case tov_None:
            case tov_NoGrowth:
            case tov_OFirstYearDanger:
                break;
 
            default:
                m_OurLandscape->Warn("Roe_Base::NutriValue(x,y): Unknown vegetation type!", g_landscape_p->VegtypeToString(VegType));
                exit(1);
                break;
            }
        }
        else DEC = 100;
    }
 
    //DEC is multiplied by monthly estimate of intake rate
    nutri = DEC * IntakeRate[month - 1];
    return (int)nutri;
}

References g_landscape_p, IntakeRate, TAnimal::m_OurLandscape, Landscape::PolytypeToString(), Landscape::SupplyDayInYear(), Landscape::SupplyElementType(), Landscape::SupplyMonth(), Landscape::SupplyVegBiomass(), Landscape::SupplyVegType(), tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_Building, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Fence, tole_Field, tole_FieldBoundary, tole_Foobar, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MixedForest, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UrbanNoVeg, tole_Vildtager, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, tov_BroadBeans, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_FieldPeas, tov_FodderBeet, tov_Heath, tov_Maize, tov_MaizeSilage, tov_MaizeStrigling, tov_NoGrowth, tov_None, tov_Oats, tov_OBarleyPeaCloverGrass, tov_OCarrots, tov_OCloverGrassGrazed1, tov_OCloverGrassGrazed2, tov_OCloverGrassSilage1, tov_OFieldPeas, tov_OFieldPeasSilage, tov_OFirstYearDanger, tov_OFodderBeet, tov_OGrazingPigs, tov_OMaizeSilage, tov_OOats, tov_OPermanentGrassGrazed, tov_OPotatoes, tov_OSBarleySilage, tov_OSpringBarley, tov_OSpringBarleyPigs, tov_OTriticale, tov_OWinterBarley, tov_OWinterRape, tov_OWinterRye, tov_OWinterWheat, tov_OWinterWheatUndersown, tov_PermanentGrassGrazed, tov_PermanentSetaside, tov_Potatoes, tov_PotatoesIndustry, tov_SeedGrass1, tov_SeedGrass2, tov_Setaside, tov_SpringBarley, tov_SpringBarleyCloverGrass, tov_SpringBarleyGrass, tov_SpringBarleySilage, tov_SpringBarleySpr, tov_SpringRape, tov_SugarBeet, tov_Triticale, tov_WinterBarley, tov_WinterRape, tov_WinterRye, tov_WinterWheat, Landscape::VegtypeToString(), and Landscape::Warn().

NutriValue() [2/2]

int Roe_Base::NutriValue ( int  polyref )

protected

Referenced by Roe_Fawn::FAFeed(), Roe_Female::FFeed(), Roe_Male::MFeed(), and SeekNutri().

NutriValueCC()

int Roe_Base::NutriValueCC ( int  p_x, int  p_y  )

inlineprotected

   {
     m_OurLandscape->CorrectCoords( p_x, p_y );
     return NutriValue( p_x, p_y );
   }

Referenced by SeekNutri().

On_ChangeGroup()

virtual void Roe_Base::On_ChangeGroup ( int  )

inlinevirtual

Reimplemented in Roe_Fawn.

{}

Referenced by Roe_Female::FFormGroup().

On_EndGroup()

virtual void Roe_Base::On_EndGroup ( )

inlinevirtual

Reimplemented in Roe_Female, and Roe_Fawn.

{}

On_IsDead()

virtual void Roe_Base::On_IsDead ( Roe_Base *  , int  , bool    )

inlinevirtual

Reimplemented in Roe_Male, Roe_Female, and Roe_Fawn.

{}

Referenced by Roe_Fawn::FADie(), and Roe_Female::FDie().

On_MumAbandon()

virtual void Roe_Base::On_MumAbandon ( Roe_Female *  )

inlinevirtual

Reimplemented in Roe_Fawn.

{}

Referenced by Roe_Female::FUpdateEnergy().

On_UpdateGroup()

virtual void Roe_Base::On_UpdateGroup ( int  , int    )

inlinevirtual

Reimplemented in Roe_Female, and Roe_Fawn.

{}

ProbRoadCross()

int Roe_Base::ProbRoadCross ( int  p_x, int  p_y, int  p_width  )

protected

Roe_Base::ProbRoadCross - returns the probability of crossing road, depending on traffic load and road size (width). Calls function SupplyTrafficLoad().

{
   double WidthIndex;
   double TrafficLoadIndex;
   double traffic=(double) m_OurLandscape->SupplyTrafficLoad(p_x,p_y);//absolute no. of cars/hr
   //scale width to largest roadtype to get value between 0 and 1
   WidthIndex=(double)p_width/MaxRoadWidth;
   //scale traffic to national max to get index between 0 and 1
   TrafficLoadIndex=(double)traffic/MaxTraffic;
   return  (int)(100*(2+(((TrafficLoadIndex+1)+(WidthIndex+1))/-2)));
   //returns int between 0 and 100
}

References TAnimal::m_OurLandscape, MaxRoadWidth, MaxTraffic, and Landscape::SupplyTrafficLoad().

Referenced by NextStep(), and WalkTo().

Running()

bool Roe_Base::Running ( int  x, int  y  )

protected

Roe_Base::Running - straight line movement away from danger. Avoid water, buildings and gardens, but not roads. The Direction with highest total cover value is chosen. After 150 steps, the deer checks if this habitat is safe, and if cover is not good, the deer will keep running and check if safe every 25 m. Calls DirectionTo(), Cover(), SupplyRoadWidth(), CalculateRoadMortality().

{
 //straight line movement away from danger. Avoid water, buildings and gardens,
 //but not roads.
 
  int t[8];
  int q[8];
  q[5]=0;
  q[6]=0;
  q[7]=0;
  bool IsSafe=false;
  //get direction to threat
  int dir=DirectionTo(m_Location_x,m_Location_y,x,y);
 
  //get cover in 3 directions from 0-50 m.
  for (int i=0; i<50; i++)
  {
    t[5]=dir+3;
    t[5]=(t[5]+8) & 7;
    t[6]=dir-3;
    t[6]=(t[6]+8) & 7;
    t[7]=dir+4;
    t[7]=(t[6]+8) & 7;
    q[5]+=Cover(m_Location_x+Vector_x[t[5]], m_Location_y+Vector_y[t[5]]); //sums cover for each dir
    q[6]+=Cover(m_Location_x+Vector_x[t[6]], m_Location_y+Vector_y[t[6]]);
    q[7]+=Cover(m_Location_x+Vector_x[t[7]], m_Location_y+Vector_y[t[7]]);
  }
//get direction with highest total cover value = int thisway
  int max=q[5];
  int thisway;
 
  if (q[6]>max) thisway=t[6];
  else if (q[7]>max) thisway=t[7];
  else thisway=t[5];
 
  for (int i=0; i<200; i++)   //take 200 steps in that direction
  { //make sure habitat is usable(Cover !=-1)
    int rightway=0;
    if (Cover(m_Location_x+Vector_x[thisway],m_Location_y+Vector_y[thisway])==-1)  //thisway not possible, check +/- 1
    {
      //random pick between the other two directions
      int pick = random(2);
      if (pick==0)
      { //try -1 first
        if (Cover(m_Location_x+Vector_x[(thisway-1+8) & 0x07],
          m_Location_y+Vector_y[(thisway-1+8) & 0x07])!=-1)
        {
          rightway=thisway-1;
        }
        else rightway=thisway+1;
      }
      else  //try +1 first
      {
        if (Cover(m_Location_x+Vector_x[(thisway+1+8) & 0x07],
          m_Location_y+Vector_y[(thisway+1+8) & 0x07])!=-1)
        {
          rightway=thisway+1;
        }
        else rightway=thisway-1;
      }
    }
    //check if rightway is road
    if (Cover(m_Location_x+Vector_x[rightway],
          m_Location_y+Vector_y[rightway])==1)
    {
      //get width of road
      int width=m_OurLandscape->SupplyRoadWidth(
         m_Location_x+Vector_x[rightway],
     m_Location_y+Vector_y[rightway]);
 
 
      double mort=CalculateRoadMortality(
         m_Location_x+Vector_x[rightway],
     m_Location_y+Vector_y[rightway],width);
      int rand=random(100);
      //if(mort<rand) //roe dies
      if(mort<(double)rand) //roe dies
      {
        m_IsDead=true;
      }
    }
     //change coordinates
    m_Location_x+= Vector_x[t[rightway]];
    m_Location_y+= Vector_y[t[rightway]];
  }
 
  //150 steps are taken, now check if this habitat is safe (cover>=2)
  if (Cover(m_Location_x,m_Location_y)>2)
  {
    IsSafe=true;
  }
  else  //cover not good, so keep running and check if safe every 25 m
  {
    int loop=0; //counts how many times through the for-loop, time's up after 6 (450 steps)
    while ((IsSafe==false)&&(loop<=6))
    {
      for (int i=0; i<25; i++)
      { //make sure habitat is usable(Cover !=-1)
        int rightway=0;
        if (Cover(m_Location_x+Vector_x[thisway],
                                          m_Location_y+Vector_y[thisway])==-1)
                                          //thisway not possible, check +/- 1
        {
          //random pick between the other two directions
          int pick = random(2);
          if (pick==0)
          { //try -1 first
            if (Cover(m_Location_x+Vector_x[(thisway-1+8) & 0x07],
              m_Location_y+Vector_y[(thisway-1+8) & 0x07])!=-1)
            {
              rightway=thisway-1;
            }
            else rightway=thisway+1;
          }
          else  //try +1 first
          {
            if (Cover(m_Location_x+Vector_x[(thisway+1+8) & 0x07],
              m_Location_y+Vector_y[(thisway+1+8) & 0x07])!=-1)
            {
              rightway=thisway+1;
            }
            else rightway=thisway-1;
          }
        }
        loop++;
        //change coordinates and check if safe now
        m_Location_x+= Vector_x[t[rightway]];
        m_Location_y+= Vector_y[t[rightway]];
 
        if (Cover(m_Location_x,m_Location_y)>2)
        {
          IsSafe=true;
        }
        else IsSafe=false;  //keep running in next time step
      }
    }
  }
  return IsSafe;
}

References CalculateRoadMortality(), Cover(), DirectionTo(), m_IsDead, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, random(), Landscape::SupplyRoadWidth(), Vector_x, and Vector_y.

Referenced by Roe_Female::FRun(), Roe_Male::MRun(), and Roe_Fawn::On_ApproachOfDanger().

SeekCover()

void Roe_Base::SeekCover ( int  threshold )

protected

Roe_Base::SeekCover - Method for locating good spot based on cover. Used to find place to ruminate and fawn bedsites. Threshold is the minimum acceptable cover value Calls CoverCC(), WalkToCC(), Cover(), WalkTo().

{
  int t[8];
  int q[8];
  int dir=random(8);   //start looking in any direction
  bool found=false;
  bool correct=false;
  t[0]=dir & 7;
  t[1]=(dir+1) & 7;
  t[2]=(dir+7) & 7;
  t[3]=(dir+10) & 7;
  t[4]=(dir+6) & 7;
  t[5]=(dir+11) & 7;
  t[6]=(dir+5) & 7;
  t[7]=(dir+12) & 7;
  int x=m_Location_x;
  int y=m_Location_y;
 
  //need to correct coordinates
  if((x <= 100)||(x >= SimW-100)||(y <= 100)||(y >= SimH-100))//could step out of area
  {
    correct=true;
    x += SimW;
    y += SimH;
    for (int i=0; i< 100; i++)       //up to 100 steps at a time
    {
      q[0]=CoverCC( x+(Vector_x[t[0]]*i), y+(Vector_y[t[0]]*i) );
      q[1]=CoverCC( x+(Vector_x[t[1]]*i), y+(Vector_y[t[1]]*i) );
      q[2]=CoverCC( x+(Vector_x[t[2]]*i), y+(Vector_y[t[2]]*i) );
      q[3]=CoverCC( x+(Vector_x[t[3]]*i), y+(Vector_y[t[3]]*i) );
      q[4]=CoverCC( x+(Vector_x[t[4]]*i), y+(Vector_y[t[4]]*i) );
      q[5]=CoverCC( x+(Vector_x[t[5]]*i), y+(Vector_y[t[5]]*i) );
      q[6]=CoverCC( x+(Vector_x[t[6]]*i), y+(Vector_y[t[6]]*i) );
      q[7]=CoverCC( x+(Vector_x[t[7]]*i), y+(Vector_y[t[7]]*i) );
      if ((q[0]>=threshold)||(q[1]>=threshold)||(q[2]>=threshold)||
            (q[3]>=threshold)||(q[4]>=threshold)||(q[5]>=threshold)||
               (q[6]>=threshold)||(q[7]>=threshold))
      {
        //which direction is it?
        int thisway;
        int score=-1;
        int index[8];
        for (int j=0; j<8; j++)
        {
          if (q[j]>=threshold)
          {
            score++;  //this many suitable
            index[score]=j;
          }
        }
        int rand = random(score+1);
        thisway=t[index[rand]];
 
        //walk to that place
        WalkToCC( x+(Vector_x[thisway]*i), y+(Vector_y[thisway]*i) );
        found=true;
        break;   //don't look any further
      }
    }
  }
  else //no need to correct area
  {
     for (int i=2; i< 100; i+=2)       //up to 100 steps at a time
    {
      q[0]=Cover(x+(Vector_x[t[0]]*i),y+(Vector_y[t[0]]*i));
      q[1]=Cover(x+(Vector_x[t[1]]*i),y+(Vector_y[t[1]]*i));
      q[2]=Cover(x+(Vector_x[t[2]]*i),y+(Vector_y[t[2]]*i));
      q[3]=Cover(x+(Vector_x[t[3]]*i),y+(Vector_y[t[3]]*i));
      q[4]=Cover(x+(Vector_x[t[4]]*i),y+(Vector_y[t[4]]*i));
      q[5]=Cover(x+(Vector_x[t[5]]*i),y+(Vector_y[t[5]]*i));
      q[6]=Cover(x+(Vector_x[t[6]]*i),y+(Vector_y[t[6]]*i));
      q[7]=Cover(x+(Vector_x[t[7]]*i),y+(Vector_y[t[7]]*i));
      if ((q[0]>=threshold)||(q[1]>=threshold)||(q[2]>=threshold)||
            (q[3]>=threshold)||(q[4]>=threshold)||(q[5]>=threshold)||
               (q[6]>=threshold)||(q[7]>=threshold))
      {
        //which direction is it?
        int thisway;
        int score=-1;
        int index[8];
        for (int j=0; j<8; j++)
        {
          if (q[j]>=threshold)
          {
            score++;  //this many suitable
            index[score]=j;
          }
        }
        int rand = random(score+1);
        thisway=t[index[rand]];
        //walk to that place
        WalkTo(x+(Vector_x[thisway]*i),y+(Vector_y[thisway]*i));
        found=true;
        break;   //don't look any further
      }
    }
  }
  if((!found)&&(!correct))//always need to correct now for this last bit
  {
    x+=SimW;
    y+=SimH;
  }
  int i=100;
  while(!found)
  {
      q[0]=CoverCC( x+(Vector_x[t[0]]*i), y+(Vector_y[t[0]]*i) );
      q[1]=CoverCC( x+(Vector_x[t[1]]*i), y+(Vector_y[t[1]]*i) );
      q[2]=CoverCC( x+(Vector_x[t[2]]*i), y+(Vector_y[t[2]]*i) );
      q[3]=CoverCC( x+(Vector_x[t[3]]*i), y+(Vector_y[t[3]]*i) );
      q[4]=CoverCC( x+(Vector_x[t[4]]*i), y+(Vector_y[t[4]]*i) );
      q[5]=CoverCC( x+(Vector_x[t[5]]*i), y+(Vector_y[t[5]]*i) );
      q[6]=CoverCC( x+(Vector_x[t[6]]*i), y+(Vector_y[t[6]]*i) );
      q[7]=CoverCC( x+(Vector_x[t[7]]*i), y+(Vector_y[t[7]]*i) );
      if ((q[0]>=threshold)||(q[1]>=threshold)||(q[2]>=threshold)||
            (q[3]>=threshold)||(q[4]>=threshold)||(q[5]>=threshold)||
               (q[6]>=threshold)||(q[7]>=threshold))
      {
        //which direction is it?
        int thisway;
        int score=-1;
        int index[8];
        for (int j=0; j<8; j++)
        {
          if (q[j]>=threshold)
          {
            score++;  //this many suitable
            index[score]=j;
          }
        }
        int rand = random(score+1);
        thisway=t[index[rand]];
 
        //walk to that place
        WalkToCC( x+(Vector_x[thisway]*i), y+(Vector_y[thisway]*i) );
        found=true;
        break;   //don't look any further
      }
      i+=2;
      if(i>SimH)
      {
        m_OurLandscape ->Warn("Roe_Base:SeekCover():Variable out of range, i","");
        exit( 1 );
      }
  }
}

References Cover(), CoverCC(), TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, random(), SimH, SimW, Vector_x, Vector_y, WalkTo(), WalkToCC(), and Landscape::Warn().

Referenced by Roe_Fawn::FARuminate(), Roe_Female::FRuminate(), Roe_Male::MRuminate(), and Roe_Fawn::SelectBedSite().

SeekNutri()

void Roe_Base::SeekNutri ( int  threshold )

protected

Roe_Base::SeekNutri - locates good spot to feed based on Digestable energy content (DEC). Searches outwards in all directions for better quality. Equals 10 minutes of search activity. Calls NutriValueCC(), WalkToCC(), WalkTo(), NutriValue().

{
  int dir=random(8);   //start looking in any direction
  int t[8];
  int q[8];
  t[0]=dir & 7;
  t[1]=(dir+1) & 7;
  t[2]=(dir+7) & 7;
  t[3]=(dir+10) & 7;
  t[4]=(dir+6) & 7;
  t[5]=(dir+11) & 7;
  t[6]=(dir+5) & 7;
  t[7]=(dir+12) & 7;
  //need to correct coordinates
  int x=m_Location_x;
  int y=m_Location_y;
  bool found=false;
  bool correct=false;
 
  if((x <= 100)||(x >= SimW-100)||(y <= 100)||(y >= SimH-100))//could step out of area
  {
    correct=true;
    x += SimW;
    y += SimH;
    for (int i=2; i< 100; i+=2)       //check up till 100 steps away
    {
      q[0]=NutriValueCC( x+(Vector_x[t[0]]*i), y+(Vector_y[t[0]]*i) );
      q[1]=NutriValueCC( x+(Vector_x[t[1]]*i), y+(Vector_y[t[1]]*i) );
      q[2]=NutriValueCC( x+(Vector_x[t[2]]*i), y+(Vector_y[t[2]]*i) );
      q[3]=NutriValueCC( x+(Vector_x[t[3]]*i), y+(Vector_y[t[3]]*i) );
      q[4]=NutriValueCC( x+(Vector_x[t[4]]*i), y+(Vector_y[t[4]]*i) );
      q[5]=NutriValueCC( x+(Vector_x[t[5]]*i), y+(Vector_y[t[5]]*i) );
      q[6]=NutriValueCC( x+(Vector_x[t[6]]*i), y+(Vector_y[t[6]]*i) );
      q[7]=NutriValueCC( x+(Vector_x[t[7]]*i), y+(Vector_y[t[7]]*i) );
      if ((q[0]>=threshold)||(q[1]>=threshold)||(q[2]>=threshold)||
            (q[3]>=threshold)||(q[4]>=threshold)||(q[5]>=threshold)||
               (q[6]>=threshold)||(q[7]>=threshold))
      {
        //which direction is it?
        int thisway;
        int score=-1;
        int index[8];
        int best = q[0];
        for (int j=0; j<8; j++)
        {
          if (q[j]>best)  //only 1 best choice
          {
            best = q[j];
            score = 0;
            index[score]=j;
          }
          else if (q[j]==best)
          {
            score++;  //this many suitable
            index[score]=j;
          }
        }
        if (score==0)
        {
          thisway = t[index[score]];
        }
        else if (score >0)
        {
          int rand = random(score+1);
          thisway=t[index[rand]];
        }
        //walk to that place
        WalkToCC( x+(Vector_x[thisway]*i), y+(Vector_y[thisway]*i) );
        found=true;
        break;   //don't look any further
      }
    }
  }
  else //no need to correct area
  {
    for (int i=2; i< 100; i+=2)       //up till 200 steps at a time
    {
      q[0]=NutriValue(x+(Vector_x[t[0]]*i),y+(Vector_y[t[0]]*i));
      q[1]=NutriValue(x+(Vector_x[t[1]]*i),y+(Vector_y[t[1]]*i));
      q[2]=NutriValue(x+(Vector_x[t[2]]*i),y+(Vector_y[t[2]]*i));
      q[3]=NutriValue(x+(Vector_x[t[3]]*i),y+(Vector_y[t[3]]*i));
      q[4]=NutriValue(x+(Vector_x[t[4]]*i),y+(Vector_y[t[4]]*i));
      q[5]=NutriValue(x+(Vector_x[t[5]]*i),y+(Vector_y[t[5]]*i));
      q[6]=NutriValue(x+(Vector_x[t[6]]*i),y+(Vector_y[t[6]]*i));
      q[7]=NutriValue(x+(Vector_x[t[7]]*i),y+(Vector_y[t[7]]*i));
      if ((q[0]>=threshold)||(q[1]>=threshold)||(q[2]>=threshold)||
            (q[3]>=threshold)||(q[4]>=threshold)||(q[5]>=threshold)||
               (q[6]>=threshold)||(q[7]>=threshold))
      {
        //which direction is it?
        int thisway;
        int score=-1;
        int index[8];
        int best = q[0];
        for (int j=0; j<8; j++)
        {
          if (q[j]>best)  //only 1 best choice
          {
            best = q[j];
            score = 0;
            index[score]=j;
          }
          else if (q[j]==best)
          {
            score++;  //this many suitable
            index[score]=j;
          }
        }
        if (score==0)
        {
          thisway = t[index[score]];
        }
        else if (score >0)
        {
          int rand = random(score+1);
          thisway=t[index[rand]];
        }
        //walk to that place
        WalkTo( x+(Vector_x[thisway]*i), y+(Vector_y[thisway]*i) );
        found=true;
        break;   //don't look any further
      }
    }
  }
  if((!found)&&(!correct))//always need to correct now for this last bit
  {
    x+=SimW;
    y+=SimH;
  }
  int i=100;
  while(!found)
  {
      q[0]=NutriValueCC( x+(Vector_x[t[0]]*i), y+(Vector_y[t[0]]*i) );
      q[1]=NutriValueCC( x+(Vector_x[t[1]]*i), y+(Vector_y[t[1]]*i) );
      q[2]=NutriValueCC( x+(Vector_x[t[2]]*i), y+(Vector_y[t[2]]*i) );
      q[3]=NutriValueCC( x+(Vector_x[t[3]]*i), y+(Vector_y[t[3]]*i) );
      q[4]=NutriValueCC( x+(Vector_x[t[4]]*i), y+(Vector_y[t[4]]*i) );
      q[5]=NutriValueCC( x+(Vector_x[t[5]]*i), y+(Vector_y[t[5]]*i) );
      q[6]=NutriValueCC( x+(Vector_x[t[6]]*i), y+(Vector_y[t[6]]*i) );
      q[7]=NutriValueCC( x+(Vector_x[t[7]]*i), y+(Vector_y[t[7]]*i) );
      if ((q[0]>=threshold)||(q[1]>=threshold)||(q[2]>=threshold)||
            (q[3]>=threshold)||(q[4]>=threshold)||(q[5]>=threshold)||
               (q[6]>=threshold)||(q[7]>=threshold))
      {
        //which direction is it?
        int thisway;
        int score=-1;
        int index[8];
        for (int j=0; j<8; j++)
        {
          if (q[j]>=threshold)
          {
            score++;  //this many suitable
            index[score]=j;
          }
        }
        int rand = random(score+1);
        thisway=t[index[rand]];
        //walk to that place
        WalkToCC( x+(Vector_x[thisway]*i), y+(Vector_y[thisway]*i) );
        found=true;
        break;   //don't look any further
      }
      i+=2;
      if(i>SimH)
      {
        m_OurLandscape ->Warn("Roe_Base:SeekCover():Variable out of range, i","");
        exit( 1 );
      }
  }
 
}

References TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, NutriValue(), NutriValueCC(), random(), SimH, SimW, Vector_x, Vector_y, WalkTo(), WalkToCC(), and Landscape::Warn().

Referenced by Roe_Female::FFeed(), and Roe_Male::MFeed().

Send_IsDead()

virtual void Roe_Base::Send_IsDead ( )

inlinevirtual

{}

Step()

void Roe_Base::Step ( void  )

virtual

Step behaviour - must be implemented in descendent classes.

Reimplemented from TAnimal.

Reimplemented in Roe_Male, Roe_Female, Roe_Fawn, and Roe_Adult_Base.

{
 if (m_StepDone || (m_CurrentStateNo==-1)) return;
 
}

References TALMaSSObject::m_CurrentStateNo, and TALMaSSObject::m_StepDone.

SupplyInfo()

RoeDeerInfo Roe_Base::SupplyInfo

(

)

Roe_Base::SupplyInfo - returns info on age, size, range center.

{
   RoeDeerInfo RDI;
   RDI.m_Age = m_Age;
   RDI.m_Size = m_Size;
   RDI.m_Range_x = m_RangeCentre_x;
   RDI.m_Range_y = m_RangeCentre_y;
   RDI.m_OldRange_x = m_OldRange_x;
   RDI.m_OldRange_y = m_OldRange_y;
 
 
   return RDI;
}

References RoeDeerInfo::m_Age, m_Age, RoeDeerInfo::m_OldRange_x, m_OldRange_x, RoeDeerInfo::m_OldRange_y, m_OldRange_y, RoeDeerInfo::m_Range_x, RoeDeerInfo::m_Range_y, m_RangeCentre_x, m_RangeCentre_y, RoeDeerInfo::m_Size, and m_Size.

Referenced by Roe_Fawn::FAInit(), Roe_Female::FFormGroup(), Roe_Male::MEstablishTerritory(), Roe_Male::On_IsDead(), Roe_Male::On_Rank(), RoeDeer_Population_Manager::SupplyFemaleRC(), RoeDeer_Population_Manager::SupplyMaleRC(), and RoeDeer_Population_Manager::UpdateRanges().

SupplyReserves()

int Roe_Base::SupplyReserves ( )

inline

{return m_Reserves;}

WalkTo()

void Roe_Base::WalkTo ( int  pos_x, int  pos_y  )

protected

Roe_Base::WalkTo - directed movement towards a position, all habitat except lethal habitat is used. Roads can be crossed, but mortality probability due to road crossing is calculated. Calls DirectionTo(), LegalHabitatCC(), CorrectCoords(), SupplyRoadWidth(), CalculateRoadMortality(), DirectionToCC().

{
  //directed movement towards a position, all habitat except lethal
  //habitat is used. Roads can be crossed
  int t[8];
  int q[8];
  bool found=false;
  int x=m_Location_x+SimW;
  int y=m_Location_y+SimH;
  int step=0;
  //First get direction and distance to the position
  int dir=DirectionTo(m_Location_x,m_Location_y,pos_x,pos_y);
  int dist=DistanceTo(m_Location_x,m_Location_y,pos_x,pos_y);
  int range=4*dist;
  //Is it possible to go in preferred direction?
  for (int i=0; i<range; i++)
  {
    t[0]=(dir+8) & 7;
    q[0]=LegalHabitatCC( x+Vector_x[t[0]], y+Vector_y[t[0]] );
    if(q[0]>0)  //good habitat
    {
       found=true;
       step=1;
    }
    else if(q[0]==0) //road, check if possible to cross
    {
      int check; //check habitat on other side of road
      int cross=random(100);
      //get width of road
      int xi = x+Vector_x[t[0]];
      int yi = y+Vector_y[t[0]];
      m_OurLandscape->CorrectCoords( xi, yi );
      int width=m_OurLandscape->SupplyRoadWidth( xi, yi );
      int prob=ProbRoadCross( xi, yi, width );
      if(prob<cross) //yes roe will cross
      {
        double mort=CalculateRoadMortality( xi, yi, width );
        int die=random(100);
        if (die<mort)  //roe dies
        {
          m_IsDead=true;
        }
        else  //survives
        {  //locate the other side of road
          for(int j=1;j<20;j++) {
            int road=LegalHabitatCC( x+Vector_x[t[0]]*j, y+Vector_y[t[0]]*j);
            if(road!= 0) {
          //not road anymore
              //check 3 steps further on other side of road.
          //If road or urban you can't cross
              check = LegalHabitatCC( x+(Vector_x[t[0]]*(j+3)),
                      y+(Vector_y[t[0]]*(j+3)) );
              if(check>1) //OK
              {
                found=true;
                step=j;   //need to walk this many steps to get across
              }
              break;
            }
          }
        }
      }
    }
    if(found)
    {
        //change coordinates
        x +=(Vector_x[t[0]]*step);
        y +=(Vector_y[t[0]]*step);
    }
    else //unsuitable habitat or road that cannot be crossed
    {
      //check the remaining directions
      t[1]=(dir+7) & 7;
      t[2]=(dir+9) & 7;
      t[3]=(dir+6) & 7;
      t[4]=(dir+10) & 7;
      t[5]=(dir+11) & 7;
      t[6]=(dir+5) & 7;
      t[7]=(dir+12) & 7;
      q[1]=LegalHabitatCC( x+Vector_x[t[1]], y+Vector_y[t[1]] );
      q[2]=LegalHabitatCC( x+Vector_x[t[2]], y+Vector_y[t[2]] );
      q[3]=LegalHabitatCC( x+Vector_x[t[3]], y+Vector_y[t[3]] );
      q[4]=LegalHabitatCC( x+Vector_x[t[4]], y+Vector_y[t[4]] );
      q[5]=LegalHabitatCC( x+Vector_x[t[5]], y+Vector_y[t[5]] );
      q[6]=LegalHabitatCC( x+Vector_x[t[6]], y+Vector_y[t[6]] );
      q[7]=LegalHabitatCC( x+Vector_x[t[7]], y+Vector_y[t[7]] );
      //evaluate all directions
      for (int j=1; j<8;j++)
      {
        if(q[j]>0)  //only evaluate better than road
        {
          found=true;
          step=1;
          //change coordinates
          x +=Vector_x[t[j]]*step;
          y +=Vector_y[t[j]]*step;
          break;
        }
      }
    }
    //check distance and direction now
    dir=DirectionToCC( x, y, pos_x, pos_y );
    dist=DistanceToCC( x, y, pos_x, pos_y );
    if (dist==0) break;
  }
  if(found)
  {
    //change roes position
    m_Location_x=x;
    m_Location_y=y;
    m_OurLandscape->CorrectCoords( m_Location_x, m_Location_y );
  }
}

References CalculateRoadMortality(), Landscape::CorrectCoords(), DirectionTo(), DirectionToCC(), DistanceTo(), DistanceToCC(), LegalHabitatCC(), m_IsDead, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, ProbRoadCross(), random(), SimH, SimW, Landscape::SupplyRoadWidth(), Vector_x, and Vector_y.

Referenced by Roe_Fawn::FASuckle(), Roe_Male::MAttendFemale(), Roe_Male::On_InHeat(), SeekCover(), SeekNutri(), and Roe_Fawn::SelectBedSite().

WalkToCC()

void Roe_Base::WalkToCC ( int  pos_x, int  pos_y  )

inlineprotected

   {
     m_OurLandscape->CorrectCoords( pos_x, pos_y );
     WalkTo( pos_x, pos_y );
   }

Referenced by SeekCover(), and SeekNutri().

WhatState()

virtual int Roe_Base::WhatState ( )

inlinevirtual

Reimplemented from TAnimal.

{return (int) CurrentRState;}

Member Data Documentation

Alive

unsigned Roe_Base::Alive

Referenced by Roe_Base(), and ~Roe_Base().

CurrentRState

TRoeDeerStates Roe_Base::CurrentRState

Referenced by Roe_Fawn::BeginStep(), Roe_Male::BeginStep(), Roe_Fawn::EndStep(), Roe_Female::EndStep(), Roe_Male::EndStep(), Roe_Fawn::On_ApproachOfDanger(), Roe_Female::On_ApproachOfDanger(), Roe_Male::On_ApproachOfDanger(), Roe_Female::On_EndCare(), Roe_Male::On_Expelled(), Roe_Male::On_InHeat(), Roe_Female::On_InitCare(), Roe_Fawn::On_IsDead(), Roe_Female::On_IsDead(), Roe_Male::On_IsDead(), Roe_Fawn::On_MumAbandon(), Roe_Base(), Roe_Fawn::Send_InitCare(), Roe_Fawn::Step(), Roe_Female::Step(), and Roe_Male::Step().

m_Age

int Roe_Base::m_Age

Referenced by Roe_Male::BeginStep(), Roe_Fawn::FADie(), Roe_Fawn::FAFeed(), Roe_Fawn::FAHide(), Roe_Fawn::FAInit(), Roe_Fawn::FAOnNewDay(), Roe_Fawn::FARecover(), Roe_Fawn::FARuminate(), Roe_Fawn::FARunToMother(), Roe_Fawn::FASuckle(), Roe_Fawn::FAUpdateEnergy(), Roe_Female::FDie(), Roe_Female::FOnNewDay(), Roe_Female::FUpdateEnergy(), Roe_Female::FUpdateGestation(), Roe_Fawn::Mature(), Roe_Male::MDie(), Roe_Male::MEstablishTerritory(), Roe_Male::MOnNewDay(), Roe_Fawn::On_ApproachOfDanger(), Roe_Male::On_InHeat(), Roe_Fawn::On_IsDead(), Roe_Male::On_IsDead(), Roe_Fawn::On_MumAbandon(), Roe_Male::On_Rank(), Roe_Fawn::Roe_Fawn(), Roe_Female::Roe_Female(), Roe_Male::Roe_Male(), and SupplyInfo().

m_Cross_x

int Roe_Base::m_Cross_x

protected

Referenced by NextStep(), and Roe_Base().

m_Cross_y

int Roe_Base::m_Cross_y

protected

Referenced by NextStep(), and Roe_Base().

m_danger_x

int Roe_Base::m_danger_x

protected

Referenced by Roe_Female::FEvade(), Roe_Female::FRun(), Roe_Male::MEvade(), Roe_Male::MRun(), Roe_Female::On_ApproachOfDanger(), Roe_Male::On_ApproachOfDanger(), Roe_Base(), and Roe_Fawn::RunTo().

m_danger_y

int Roe_Base::m_danger_y

protected

Referenced by Roe_Female::FEvade(), Roe_Female::FRun(), Roe_Male::MEvade(), Roe_Male::MRun(), Roe_Female::On_ApproachOfDanger(), Roe_Male::On_ApproachOfDanger(), Roe_Base(), and Roe_Fawn::RunTo().

m_Disperse

bool Roe_Base::m_Disperse

Referenced by Roe_Female::FDisperse(), Roe_Female::FEstablishRange(), Roe_Female::FFeed(), Roe_Female::FFormGroup(), Roe_Female::FOnNewDay(), Roe_Female::FRuminate(), Roe_Male::MDisperse(), Roe_Male::MEstablishRange(), Roe_Male::MEstablishTerritory(), Roe_Male::MFeed(), Roe_Male::MOnNewDay(), Roe_Male::MRuminate(), Roe_Male::On_IsDead(), Roe_Male::On_Rank(), and Roe_Base().

m_distrc

int Roe_Base::m_distrc

protected

Referenced by Feeding().

m_EnergyGained

double Roe_Base::m_EnergyGained

protected

Referenced by Roe_Fawn::FAFeed(), Roe_Fawn::FASuckle(), Roe_Fawn::FAUpdateEnergy(), Roe_Female::FFeed(), Roe_Female::FUpdateEnergy(), Roe_Male::MFeed(), Roe_Male::MUpdateEnergy(), and Roe_Base().

m_FeedCount

int Roe_Base::m_FeedCount

protected

Referenced by Roe_Fawn::FAFeed(), Roe_Fawn::FARecover(), Roe_Female::FFeed(), Roe_Female::FRecover(), Roe_Male::MFeed(), Roe_Male::MRecover(), and Roe_Base().

m_FixlistNumber

int Roe_Base::m_FixlistNumber

Referenced by RoeDeer_Population_Manager::CreateObjects(), RoeDeer_Population_Manager::DoFirst(), Roe_Female::FDie(), Roe_Male::MDie(), and Roe_Base().

m_float

bool Roe_Base::m_float

Referenced by Roe_Female::FEstablishRange(), Roe_Female::FOnNewDay(), Roe_Male::MEstablishRange(), Roe_Male::MOnNewDay(), Roe_Female::On_CanJoinGroup(), Roe_Male::On_Expelled(), Roe_Male::On_Rank(), Roe_Base(), and Roe_Female::~Roe_Female().

m_HaveRange

bool Roe_Base::m_HaveRange

Referenced by RoeDeer_Population_Manager::DoFirst(), Roe_Female::FDisperse(), Roe_Female::FEstablishRange(), Roe_Female::FUpdateGestation(), Roe_Male::MDisperse(), Roe_Male::MEstablishRange(), Roe_Male::MOnNewDay(), Roe_Male::On_Rank(), Roe_Base(), Roe_Female::Roe_Female(), Roe_Male::Roe_Male(), and RoeDeer_Population_Manager::UpdateRanges().

m_HomeRange

double Roe_Base::m_HomeRange

Referenced by Roe_Base().

m_ID

int Roe_Base::m_ID

Referenced by RoeDeer_Population_Manager::CreateObjects(), and Roe_Fawn::Mature().

m_IsDead

bool Roe_Base::m_IsDead

Referenced by Roe_Fawn::FAHide(), Roe_Fawn::FARuminate(), Roe_Fawn::FARunToMother(), Feeding(), Roe_Female::FFeed(), Roe_Female::FRuminate(), Roe_Female::FRun(), Roe_Male::MFeed(), Roe_Male::MRuminate(), Roe_Male::MRun(), Roe_Fawn::On_ApproachOfDanger(), Roe_Fawn::On_IsDead(), Roe_Fawn::On_MumAbandon(), Roe_Fawn::Roe_Fawn(), Roe_Female::Roe_Female(), Roe_Male::Roe_Male(), Running(), Roe_Fawn::RunTo(), and WalkTo().

m_LastState

int Roe_Base::m_LastState

protected

Referenced by Roe_Fawn::FAFeed(), Roe_Fawn::FAHide(), Roe_Fawn::FARecover(), Roe_Fawn::FARuminate(), Roe_Fawn::FASuckle(), Roe_Fawn::FAUpdateEnergy(), Roe_Female::FDisperse(), Roe_Female::FEvade(), Roe_Female::FFeed(), Roe_Female::FIgnore(), Roe_Female::FInHeat(), Roe_Female::FMate(), Roe_Female::FRecover(), Roe_Female::FRuminate(), Roe_Female::FUpdateGestation(), Roe_Male::MAttendFemale(), Roe_Male::MDisperse(), Roe_Male::MEvade(), Roe_Male::MFeed(), Roe_Male::MIgnore(), Roe_Male::MRecover(), Roe_Male::MRuminate(), Roe_Male::MUpdateEnergy(), Roe_Fawn::Roe_Fawn(), Roe_Female::Roe_Female(), and Roe_Male::Roe_Male().

m_LengthFeedPeriod

int Roe_Base::m_LengthFeedPeriod

protected

Referenced by Roe_Fawn::FAFeed(), Roe_Fawn::FAUpdateEnergy(), Roe_Female::FFeed(), Roe_Female::FUpdateEnergy(), Roe_Male::MFeed(), Roe_Male::MUpdateEnergy(), Roe_Base(), and Roe_Fawn::Roe_Fawn().

m_LengthRuminate

int Roe_Base::m_LengthRuminate

protected

Referenced by Roe_Fawn::FAFeed(), Roe_Fawn::FARuminate(), Roe_Female::FFeed(), Roe_Female::FRuminate(), Roe_Male::MFeed(), Roe_Male::MRuminate(), and Roe_Base().

m_OldRange_x

int Roe_Base::m_OldRange_x

Referenced by Roe_Female::FDisperse(), Roe_Female::FEstablishRange(), Roe_Female::FOnNewDay(), Roe_Male::MDisperse(), Roe_Male::MOnNewDay(), Roe_Female::On_EndGroup(), Roe_Female::On_UpdateGroup(), Roe_Base(), and SupplyInfo().

m_OldRange_y

int Roe_Base::m_OldRange_y

Referenced by Roe_Female::FDisperse(), Roe_Female::FEstablishRange(), Roe_Female::FOnNewDay(), Roe_Male::MDisperse(), Roe_Male::MOnNewDay(), Roe_Female::On_EndGroup(), Roe_Female::On_UpdateGroup(), Roe_Base(), and SupplyInfo().

m_OurPopulation

RoeDeer_Population_Manager* Roe_Base::m_OurPopulation

Referenced by Roe_Female::AddFawnToList(), Roe_Male::BeginStep(), Roe_Fawn::EndStep(), Roe_Female::EndStep(), Roe_Male::EndStep(), Roe_Fawn::FADie(), Roe_Female::FDie(), Roe_Female::FEstablishRange(), Roe_Female::FFormGroup(), Roe_Female::FGiveBirth(), Roe_Female::FInHeat(), Roe_Female::FOnMature(), Roe_Female::FOnNewDay(), Roe_Fawn::Mature(), Roe_Male::MDie(), Roe_Male::MEstablishRange(), Roe_Male::MEstablishTerritory(), Roe_Male::MOnMature(), Roe_Male::MOnNewDay(), Roe_Male::MUpdateEnergy(), Roe_Female::On_CanJoinGroup(), Roe_Fawn::On_ChangeGroup(), Roe_Male::On_InHeat(), Roe_Female::On_InitCare(), Roe_Male::On_IsDead(), Roe_Male::On_Rank(), Roe_Base(), Roe_Female::Roe_Female(), Roe_Female::Send_EndGroup(), Roe_Fawn::~Roe_Fawn(), and Roe_Female::~Roe_Female().

m_RangeCentre_x

int Roe_Base::m_RangeCentre_x

Referenced by Roe_Fawn::FAFeed(), Roe_Female::FDisperse(), Feeding(), Roe_Female::FEstablishRange(), Roe_Female::FOnNewDay(), Roe_Male::MDisperse(), Roe_Male::MEstablishRange(), Roe_Male::MEstablishTerritory(), Roe_Female::On_EndGroup(), Roe_Male::On_InHeat(), Roe_Male::On_IsDead(), Roe_Male::On_Rank(), Roe_Female::On_UpdateGroup(), Roe_Base(), and SupplyInfo().

m_RangeCentre_y

int Roe_Base::m_RangeCentre_y

Referenced by Roe_Fawn::FAFeed(), Roe_Female::FDisperse(), Feeding(), Roe_Female::FEstablishRange(), Roe_Female::FOnNewDay(), Roe_Male::MDisperse(), Roe_Male::MEstablishRange(), Roe_Male::MEstablishTerritory(), Roe_Female::On_EndGroup(), Roe_Male::On_InHeat(), Roe_Male::On_IsDead(), Roe_Male::On_Rank(), Roe_Female::On_UpdateGroup(), Roe_Base(), and SupplyInfo().

m_RecovCount

int Roe_Base::m_RecovCount

protected

Referenced by Roe_Fawn::FARecover(), Roe_Female::FRecover(), Roe_Female::FRun(), Roe_Male::MRecover(), Roe_Male::MRun(), and Roe_Base().

m_Reserves

int Roe_Base::m_Reserves

Referenced by Roe_Fawn::FAUpdateEnergy(), Roe_Female::FUpdateEnergy(), Roe_Male::MUpdateEnergy(), Roe_Fawn::Roe_Fawn(), Roe_Female::Roe_Female(), and Roe_Male::Roe_Male().

m_RumiCount

int Roe_Base::m_RumiCount

protected

Referenced by Roe_Fawn::FARuminate(), Roe_Female::FRuminate(), Roe_Male::MRuminate(), and Roe_Base().

m_SearchRange

int Roe_Base::m_SearchRange

Referenced by Roe_Male::BeginStep(), Feeding(), Roe_Female::FEstablishRange(), Roe_Female::FFormGroup(), Roe_Female::FInHeat(), Roe_Female::FOnMature(), Roe_Female::FOnNewDay(), Roe_Male::MDie(), Roe_Male::MEstablishTerritory(), Roe_Male::MOnMature(), Roe_Male::MOnNewDay(), Roe_Male::On_IsDead(), Roe_Fawn::Roe_Fawn(), and RoeDeer_Population_Manager::UpdateRanges().

m_Sex

bool Roe_Base::m_Sex

Referenced by Roe_Fawn::FADie(), Roe_Fawn::Mature(), Roe_Fawn::Roe_Fawn(), Roe_Female::Roe_Female(), and Roe_Male::Roe_Male().

m_Size

int Roe_Base::m_Size

Referenced by Roe_Male::BeginStep(), RoeDeer_Population_Manager::DoFirst(), Roe_Fawn::FAUpdateEnergy(), Roe_Female::FGiveBirth(), Roe_Female::FUpdateEnergy(), Roe_Fawn::Mature(), Roe_Male::MEstablishRange(), Roe_Male::MEstablishTerritory(), Roe_Male::MUpdateEnergy(), Roe_Male::On_InHeat(), Roe_Female::On_InitCare(), Roe_Male::On_IsDead(), Roe_Male::On_Rank(), Roe_Fawn::Roe_Fawn(), Roe_Female::Roe_Female(), Roe_Male::Roe_Male(), and SupplyInfo().

m_weightedstep

int Roe_Base::m_weightedstep

protected

Referenced by Roe_Fawn::EndStep(), Roe_Female::EndStep(), Roe_Male::EndStep(), Feeding(), and Roe_Base().

Mum

Roe_Female* Roe_Base::Mum

Referenced by RoeDeer_Population_Manager::CreateObjects(), Roe_Fawn::FADie(), Roe_Fawn::FAFeed(), Roe_Fawn::FAHide(), Roe_Fawn::FAInit(), Roe_Fawn::FARecover(), Roe_Fawn::FARunToMother(), Roe_Fawn::FASuckle(), Roe_Female::FDie(), Roe_Fawn::Mature(), Roe_Male::MDie(), Roe_Fawn::On_IsDead(), Roe_Female::On_IsDead(), Roe_Male::On_IsDead(), Roe_Fawn::On_MumAbandon(), Roe_Female::Roe_Female(), Roe_Male::Roe_Male(), Roe_Fawn::Send_InitCare(), and Roe_Male::~Roe_Male().

SimH

int Roe_Base::SimH

protected

Referenced by DirectionTo(), DistanceTo(), Roe_Female::FEstablishRange(), NextStep(), Roe_Base(), SeekCover(), SeekNutri(), and WalkTo().

SimW

int Roe_Base::SimW

protected

Referenced by DirectionTo(), DistanceTo(), Roe_Female::FEstablishRange(), NextStep(), Roe_Base(), SeekCover(), SeekNutri(), and WalkTo().

timestep

int Roe_Base::timestep

protected

Referenced by Roe_Male::BeginStep(), Roe_Fawn::EndStep(), Roe_Female::EndStep(), Roe_Male::EndStep(), and Roe_Base().

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/RoeDeer/Roe_all.h
• /builds/a1mass/almass_stable_oddox/RoeDeer/Roe_base.cpp